package jmu.cze.service.impl;

import jmu.cze.mapper.NoteMapper;
import jmu.cze.service.NoteService;
import jmu.cze.vo.Message;
import jmu.cze.vo.Note;
import jmu.cze.vo.Revert;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.List;

@Service
public class NoteServiceImpl implements NoteService {
    private NoteMapper noteMapper;

    @Resource(name = "noteMapper")
    public void setNoteMapper(NoteMapper noteMapper) {
        this.noteMapper = noteMapper;
    }

    /**
     * 按页数获取留言（包括Message与RevertList）
     * @param page (从1开始）
     * @param limit
     * @return List<Note>
     */
    public List<Note> getNotes(int page, int limit){
        return noteMapper.getNotes((page-1)*limit,limit);
    }

    /**
     * 按关键字符串获取留言（包括Message与RevertList）
     * @param keyword
     * @return List<Note>
     */
    public List<Note> searchNotes(String keyword){
        return noteMapper.searchNotes("%"+keyword+"%");
    }

    /**
     * 按页数获取Message
     * @param productID
     * @param page (从1开始）
     * @param limit
     * @return List<Message>
     */
    public List<Message> getMessageByPage(int productID, int page, int limit) {
        return noteMapper.getMessageByPage(productID,page*limit, limit);
    }

    public List<Revert> getRevertByMessageID(int messageId) {
        return noteMapper.getRevertByMessageID(messageId);
    }

    /**
     * 获取所有Message的数目
     * @return int
     */
    public int countMessage(){
        return noteMapper.countMessage();
    }

    /**
     * 获取所有Revert的数目
     * @return int
     */
    public int countRevert(){
        return noteMapper.countRevert();
    }

    /**
     * 更新Message
     * @param message
     * @return 影响数为1->true，否则为false
     */
    public boolean updateMessage(Message message) {
        return noteMapper.updateMessage(message)==1;
    }

    /**
     * 新增Message
     * @param message
     * @return 影响数为1->true，否则为false
     */
    public boolean addMessage(Message message) {
        return noteMapper.addMessage(message)==1;
    }

    /**
     * 删除Message(管理员接口)
     * @param messageId
     * @return 影响数为1->true，否则为false
     */
    @Transactional
    public boolean deleteMessage(int messageId) {
        noteMapper.deleteRevertByMessageID(messageId);
        return noteMapper.deleteMessage(messageId)==1;
    }

    /**
     * 删除Message(普通用户接口)
     * @param messageId
     * @param writerID
     * @return 若待删除Message非改该用户所有->false，影响数为1->true，否则为false
     */
    public boolean deleteMessage(int messageId, String writerID) {
        String messageWriterID = noteMapper.getMessageWriterID(messageId);
        if(messageWriterID!=null && messageWriterID.equals(writerID)){
            return deleteMessage(messageId);
        }
        return false;
    }

    /**
     * 更新Revert
     * @param revert
     * @return 影响数为1->true，否则为false
     */
    public boolean updateRevert(Revert revert) {
        return noteMapper.updateRevert(revert)==1;
    }

    /**
     * 新增Revert
     * @param revert
     * @return 影响数为1->true，否则为false
     */
    public boolean addRevert(Revert revert) {
        return noteMapper.addRevert(revert)==1;
    }

    /**
     * 删除Revert
     * @param revertId
     * @return 影响数为1->true，否则为false
     */
    public boolean deleteRevert(int revertId) {
        return noteMapper.deleteRevert(revertId) == 1;
    }

    /**
     * 删除Revert
     * @param revertId
     * @param writerID
     * @return 若待删除Revert非改该用户所有->false，影响数为1->true，否则为false
     */
    public boolean deleteRevert(int revertId,String writerID) {
        String revertWriterID = noteMapper.getRevertWriterID(revertId);
        if(revertWriterID!=null && revertWriterID.equals(writerID)){
            return deleteRevert(revertId);
        }
        return false;
    }
}